Method and system for implementing machine learning classifications

ABSTRACT

Disclosed is a system, method, and computer program product for implementing a log analytics method and system that can configure, collect, and analyze log records in an efficient manner. Machine learning-based classification can be performed to classify logs. This approach is used to group logs automatically using a machine learning infrastructure.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present application claims the benefit of priority to U.S.Provisional Application No. 62/142,987, filed on Apr. 3, 2015, which ishereby incorporated by reference in its entirety. The presentapplication is related to (a) U.S. Ser. No. 15/088,943, entitled “METHODAND SYSTEM FOR IMPLEMENTING TARGET MODEL CONFIGURATION METADATA FOR ALOG ANALYTICS SYSTEM”, (b) U.S. Ser. No. 15/089,005, entitled “METHODAND SYSTEM FOR PARAMETERIZING LOG FILE LOCATION ASSIGNMENTS FOR A LOGANALYTICS SYSTEM”, (c) U.S. Ser. No. 15/089,049, entitled “METHOD ANDSYSTEM FOR IMPLEMENTING AN OPERATING SYSTEM HOOK INA LOG ANALYTICSSYSTEM”, (d) U.S. Ser. No. 15/089,129, entitled “METHOD AND SYSTEM FORIMPLEMENTING COLLECTION-WISE PROCESSING IN A LOG ANALYTICS SYSTEM”, (e)U.S. Ser. No. 15/089,180, entitled “METHOD AND SYSTEM FOR IMPLEMENTING ALOG PARSER IN A LOG ANALYTICS SYSTEM”, all filed on even date herewith,and which are all hereby incorporated by reference in their entirety.

BACKGROUND AND SUMMARY

Many types of computing systems and applications generate vast amountsof data pertaining to or resulting from the operation of that computingsystem or application. These vast amounts of data are stored intocollected locations, such as log files/records, which can then bereviewed at a later time period if there is a need to analyze thebehavior or operation of the system or application.

Server administrators and application administrators can benefit bylearning about and analyzing the contents of the system log records.However, it can be a very challenging task to collect and analyze theserecords. There are many reasons for these challenges.

One significant issue pertains to the fact that many modernorganizations possess a very large number of computing systems, eachhaving numerous applications that run on those computing systems. It canbe very difficult in a large system to configure, collect, and analyzelog records given the large number of disparate systems and applicationsthat run on those computing devices. Furthermore, some of thoseapplications may actually run on and across multiple computing systems,making the task of coordinating log configuration and collection evenmore problematic.

Conventional log analytics tools provide rudimentary abilities tocollect and analyze log records. However, conventional systems cannotefficiently scale when posed with the problem of massive systemsinvolving large numbers of computing systems having large numbers ofapplications running on those systems. This is because conventionalsystems often work on a per-host basis, where set-up and configurationactivities need to be performed each and every time a new host is addedor newly configured in the system, or even where new logcollection/configuration activities need to be performed for existinghosts. This approach is highly inefficient given the extensive number ofhosts that exist in modern systems. Furthermore, the conventionalapproaches, particularly on-premise solutions, also fail to adequatelypermit sharing of resources and analysis components. This causessignificant and excessive amounts of redundant processing and resourceusage.

Furthermore, conventional log analytics tools also do not provideefficient approaches to classify unknown log types. In many cases, ahighly manual process is needed to properly classify the specific typeof a given log file. In other cases, automated tools that purport toautomatically classify log file types are not accurate enough for modernbusiness environments.

Some embodiments of the invention provide a method and system toimplement machine learning-based classification of logs. This approachcan be used to group logs automatically using a machine learninginfrastructure. Other additional objects, features, and advantages ofthe invention are described in the detailed description, figures, andclaims.

BRIEF DESCRIPTION OF FIGURES

Various embodiments are described hereinafter with reference to thefigures. It should be noted that the figures are not drawn to scale andthat the elements of similar structures or functions are represented bylike reference numerals throughout the figures. It should also be notedthat the figures are only intended to facilitate the description of theembodiments. They are not intended as an exhaustive description of theinvention or as a limitation on the scope of the invention.

FIG. 1A illustrates an example system which may be employed in someembodiments of the invention.

FIG. 1B illustrates a flowchart of a method which may be employed insome embodiments of the invention.

FIG. 2 illustrates a reporting UI.

FIGS. 3A-C provide more detailed illustrations of the internal structureof the log analytics system and the components within the customerenvironment that interact with the log analytics system.

FIGS. 4A-C illustrate approaches to implement the log collectionconfiguration.

FIG. 5 shows a flowchart of an approach to implement a log collectionconfiguration by associating a log rule with a target.

FIG. 6 shows a flowchart of an approach to implement a log collectionconfiguration by associating a log source with a target.

FIG. 7 shows a flowchart of an approach to implement target-basedconfiguration for log monitoring.

FIG. 8 shows a more detailed flowchart of an approach to implementtarget-based configuration for log monitoring according to someembodiments of the invention.

FIG. 9 illustrates example XML configuration content according to someembodiments of the invention.

FIG. 10 illustrates server-side information to be included in theconfiguration file to facilitate the log parsing.

FIG. 11 shows a flowchart of one possible approach to implement thisaspect of some embodiments of the invention.

FIG. 12 illustrates an architecture for implementing some embodiments ofthe inventive approach to associate log analysis rules to variablelocations.

FIG. 13 illustrates extraction of additional data that is not consistentacross all log entries.

FIG. 14 shows some example field definitions.

FIG. 15 shows an architecture for performing machine learning-basedclassification of logs according to some embodiments of the invention.

FIG. 16 shows a high level flowchart of an approach to implement machinelearning-based classification of logs according to some embodiments ofthe invention.

FIG. 17 illustrates a flowchart of an approach to implement the learningphase according to some embodiments of the invention.

FIG. 18 illustrates an approach for organizing the known set of log datawithin the log analytics system.

FIGS. 19-1 through 19-5 illustrate the process for generating thelearning model for the different log types.

FIG. 20 shows a flowchart of an approach to implement classificationaccording to some embodiments of the invention.

FIGS. 21-1 through 21-11 illustrate a classification process.

FIG. 22 shows a flowchart of an approach to perform processing to adjustcentroids.

FIG. 23 illustrates adjustment of a similarity radius.

FIG. 24 illustrates adjustment to a number of centroids.

FIG. 25 shows a flowchart of an approach that can be taken to identifycommon and variable parts for classification.

FIGS. 26-1 through 26-3 illustrate identification of common and variableparts for classification.

FIG. 27 shows a flowchart of an approach that can be taken to identifyfield rule types for classification.

FIGS. 28-1 through 28-4 illustrate using field rule types forclassification.

FIG. 29 shows an architecture of an example computing system with whichthe invention may be implemented.

DETAILED DESCRIPTION

As noted above, many types of computing systems and applicationsgenerate vast amounts of data pertaining or resulting from operation ofthat computing system or application. These vast amounts of data arethen stored into collected locations, such as log files/records, whichcan be reviewed at a later time period if there is a need to analyze thebehavior or operation of the system or application.

Some embodiments of the invention provide a method and system toimplement machine learning-based classification of logs. This approachcan be used to group logs automatically using a machine learninginfrastructure.

While the below description may describe the invention by way ofillustration with respect to “log” data, the invention is not limited inits scope only to the analysis of log data, and indeed is applicable towide range of data types. Therefore, the invention is not to be limitedin its application only to log data unless specifically claimed as such.In addition, the following description may also interchangeably refer tothe data being processed as “records” or “messages”, without intent tolimit the scope of the invention to any particular format for the data.

Log Analytics System

This portion of the disclosure provides a description of a method andsystem for implementing high volume log collection and analytics, whichis usable in conjunction with machine learning classification of logfiles.

FIG. 1A illustrates an example system 100 for configuring, collecting,and analyzing log data according to some embodiments of the invention.System 100 includes a log analytics system 101 that in some embodimentsis embodied as a cloud-based and/or SaaS-based (software as a service)architecture. This means that log analytics system 101 is capable ofservicing log analytics functionality as a service on a hosted platform,such that each customer that needs the service does not need toindividually install and configure the service components on thecustomer's own network. The log analytics system 101 is capable ofproviding the log analytics service to multiple separate customers, andcan be scaled to service any number of customers.

Each customer network 104 may include any number of hosts 109. The hosts109 are the computing platforms within the customer network 104 thatgenerate log data as one or more log files. The raw log data producedwithin hosts 109 may originate from any log-producing source. Forexample, the raw log data may originate from a database managementsystem (DBMS), database application (DB App), middleware, operatingsystem, hardware components, or any other log-producing application,component, or system. One or more gateways 108 are provided in eachcustomer network to communicate with the log analytics system 101.

The system 100 may include one or more users at one or more userstations 103 that use the system 100 to operate and interact with thelog analytics system 101. The user station 103 comprises any type ofcomputing station that may be used to operate or interface with the loganalytics system 101 in the system 100. Examples of such user stationsinclude, for example, workstations, personal computers, mobile devices,or remote computing terminals. The user station comprises a displaydevice, such as a display monitor, for displaying a user interface tousers at the user station. The user station also comprises one or moreinput devices for the user to provide operational control over theactivities of the system 100, such as a mouse or keyboard to manipulatea pointing object in a graphical user interface to generate user inputs.In some embodiments, the user stations 103 may be (although not requiredto be) located within the customer network 104.

The log analytics system 101 comprises functionality that is accessibleto users at the user stations 101, e.g., where log analytics system 101is implemented as a set of engines, mechanisms, and/or modules (whetherhardware, software, or a mixture of hardware and software) to performconfiguration, collection, and analysis of log data. A user interface(UI) mechanism generates the UI to display the classification andanalysis results, and to allow the user to interact with the loganalytics system.

FIG. 1B shows a flowchart of an approach to use system 100 to configure,collect, and analyze log data. This discussion of FIG. 1B will refer tocomponents illustrated for the system 100 in FIG. 1A.

At 120, log monitoring is configured within the system. This may occur,for example, by a user/customer to configure the type of logmonitoring/data gathering desired by the user/customer. Within system101, a configuration mechanism 129 comprising UI controls is operable bythe user to select and configure log collection configuration 111 andtarget representations 113 for the log collection configuration.

As discussed in more detail below, the log collection configuration 111comprise the set of information (e.g., log rules, log sourceinformation, and log type information) that identify what data tocollect (e.g., which log files), the location of the data to collect(e.g., directory locations), how to access the data (e.g., the format ofthe log and/or specific fields within the log to acquire), and/or whento collect the data (e.g., on a periodic basis). The log collectionconfiguration 111 may include out-of-the-box rules that are included bya service provider. The log collection configuration 111 may alsoinclude customer-defined/customer-customized rules.

The target representations 113 identify “targets”, which are individualcomponents within the customer environment that that contain and/orproduce logs. These targets are associated with specificcomponents/hosts in the customer environment. An example target may be aspecific database application, which are associated with one or morelogs one or more hosts.

The ability of the current embodiment to configure logcollection/monitoring by associating targets with log rules and/or logsources provides unique advantages for the invention. This is becausethe user that configures log monitoring does not need to specificallyunderstand exactly how the logs for a given application are located ordistributed across the different hosts and components within theenvironment. Instead, the user only needs to select the specific target(e.g., application) for which monitoring is to be performed, and to thenconfigure the specific parameters under which the log collection processis to be performed.

This solves the significant issue with conventional systems that requireconfiguration of log monitoring on a per-host basis, where set-up andconfiguration activities need to be performed each and every time a newhost is added or newly configured in the system, or even where new logcollection/configuration activities need to be performed for existinghosts. Unlike conventional approaches, the log analytics user can beinsulated from the specifics of the exact hosts/components that pertainto the logs for a given target. This information can be encapsulated inunderlying metadata that is maintained by administrators of the systemthat understand the correspondence between the applications, hosts, andcomponents in the system.

The next action at 122 is to capture the log data according to the userconfigurations. The association between the log rules 111 and the targetrepresentations is sent to the customer network 104 for processing. Anagent of the log analytics system is present on each of the hosts 109 tocollect data from the appropriate logs on the hosts 109.

In some embodiments, data masking may be performed upon the captureddata. The masking is performed at collection time, which protects thecustomer data before it leaves the customer network. For example,various types of information in the collected log data (such as usernames and other personal information) may be sensitive enough to bemasked before it is sent to the server. Patterns are identified for suchdata, which can be removed and/or changed to proxy data before it iscollected for the server. This allows the data to still be used foranalysis purposes, while hiding the sensitive data. Some embodimentspermanently remove the sensitive data (e.g., change all such data to“***” symbols), or changed to data that is mapped so that the originaldata can be recovered.

At 124, the collected log data is delivered from the customer network104 to the log analytics system 101. The multiple hosts 109 in thecustomer network 104 provide the collected data to a smaller number ofone or more gateways 108, which then sends the log data to edge services106 at the log analytics system 101. The edge services 106 receives thecollected data one or more customer networks and places the data into aninbound data store for further processing by a log processing pipeline107.

At 126, the log processing pipeline 107 performs a series of dataprocessing and analytical operations upon the collected log data, whichis described in more detail below. At 128, the processed data is thenstored into a data storage device 110. The computer readable storagedevice 110 comprises any combination of hardware and software thatallows for ready access to the data that is located at the computerreadable storage device 110. For example, the computer readable storagedevice 110 could be implemented as computer memory operatively managedby an operating system. The data in the computer readable storage device110 could also be implemented as database objects, cloud objects, and/orfiles in a file system. In some embodiments, the processed data isstored within both a text/indexed data store 110 a (e.g., as a SOLRcluster) and a raw/historical data store 110 b (e.g., as a HDFScluster).

At 130, reporting may be performed on the processed data using areporting mechanism/UI 115. As illustrated in FIG. 2, the reporting UI200 may include a log search facility 202, one or more dashboards 204,and/or any suitable applications 206 for analyzing/viewing the processedlog data. Examples of such reporting components are described in moredetail below.

At 132, incident management may be performed upon the processed data.One or more alert conditions can be configured within log analyticssystem such that upon the detection of the alert condition, an incidentmanagement mechanism 117 provides a notification to a designated set ofusers of the incident/alert.

At 134, a Corrective Action Engine 119 may perform any necessary actionsto be taken within the customer network 104. For example, a log entrymay be received that a database system is down. When such a log entry isidentified, a possible automated corrective action is to attempt tobring the database system back up. The customer may create a correctiveaction script to address this situation. A trigger may be performed torun the script to perform the corrective action (e.g., the triggercauses an instruction to be sent to the agent on the customer network torun the script). In an alternative embodiment, the appropriate scriptfor the situation is pushed down from the server to the customer networkto be executed. In addition, at 136, any other additional functionsand/or actions may be taken as appropriate based at last upon theprocessed data.

FIG. 3A provides a more detailed illustration of the internal structureof the log analytics system at a host environment 340 and the componentswithin the customer environment 342 that interact with the log analyticssystem. This architecture 300 is configured to provide a flow for logmonitoring that is able to handle large amounts of log data ingest.

In the customer environment 342 within a single customer host/server344, the LA (log analytics) agent 333 takes the log monitoringconfiguration data 332 (e.g., sniffer configuration or target-sideconfiguration materials), and calls a log file 336 sniffer (alsoreferred to herein as the “log collector”) to gather log data from oneor more log files 338. A daemon manager 334 can be employed to interfacewith the log file sniffer 336. The log file sniffer 336 reads from oneor more log files 338 on the host machine 344. The daemon manager 334takes the log content and packages it up so that it can be handed backto the LA agent 333. It is noted that the system may include any numberof different kinds of sniffers, and a log sniffer 336 is merely anexample of a single type of sniffer that can be used in the system.Other types of sniffers may therefore be employed within variousembodiments of the invention, e.g., sniffers to monitor registries,databases, windows event logs, etc. In addition, the log sniffer in someembodiments is configured to handle collective/compressed files, e.g., aZip file.

The LA agent 333 sends the gathered log data to the gateway agent 330.The gateway agent 330 packages up the log data that is collected frommultiple customer hosts/servers, essentially acting as an aggregator toaggregate the log content from multiple hosts. The packaged content isthen sent from the gateway agent 330 to the edge services 306. The edgeservices 306 receive a large amount of data from multiple gateway agents330 from any number of different customer environments 342.

Given the potentially large volume of data that may be received at theedge services 306, the data is immediately stored into an inbound datastorage device 304 (the “platform inbound store”). This acts as a queuefor the log processing pipeline 308. A data structure is provided tomanage the items to be processed within the inbound data store. In someembodiments, a messaging platform 302 (e.g., implemented using the Kafkaproduct) can be used to track the to-be-processed items within thequeue. Within the log processing pipeline 308, a queue consumer 310identifies the next item within the queue to be processed, which is thenretrieved from the platform inbound store. The queue consumer 310comprises any entity that is capable of processing work within thesystem off the queue, such as a process, thread, node, or task.

The retrieved log data undergoes a “parse” stage 312, where the logentries are parsed and broken up into specific fields. As discussed inmore detail below, the “log type” configured for the log specifies howto break up the log entry into the desired fields.

In the “normalize” stage 314, the identified fields are normalized. Forexample, a “time” field may be represented in any number of differentways in different logs. This time field can be normalized into a singlerecognizable format (e.g., UTC format). As another example, the word“error” may be represented in different ways on different systems (e.g.,all upper case “ERROR”, all lower case “error”, first letter capitalized“Error”, or abbreviation “err”). This situation may require thedifferent word forms/types to be normalized into a single format (e.g.,all lower case un-abbreviated term “error”).

The “transform” stage 316 can be used to synthesize new content from thelog data. As an example and which will be discussed in more detailbelow, “tags” can be added to the log data to provide additionalinformation about the log entries. As another example, field extractioncan be performed to extract additional fields from the existing logentry fields.

A “condition evaluation” stage 318 is used to evaluate for specifiedconditions upon the log data. This stage can be performed to identifypatterns within the log data, and to create/identify alerts conditionswithin the logs. Any type of notifications may be performed at thisstage, including for example, emails/text messages/call sent toadministrators/customers or alert to another system or mechanism.

A log writer 320 then writes the processed log data to one or more datastores 324. In some embodiments, the processed data is stored withinboth a text/indexed data store (e.g., as a SOLR cluster) and a rawand/or historical data store (e.g., as a HDFS cluster). The log writercan also send the log data to another processing stage 322 and/ordownstream processing engine.

As shown in FIG. 3B, some embodiments provide a side loading mechanism350 to collect log data without to proceed through an agent 333 on theclient side. In this approach, the user logs into the server to selectone or more files on a local system. The system will load that file atthe server, and will sniff through that file (e.g., by having the userprovide the log type, attempting likely log types, rolling throughdifferent log types, or by making an educated “guess” of the log type).The sniffing results are then passed to the Edge Services and process aspreviously described. In the embodiment, of FIG. 3C, only the sideloading mechanism 350 exists to gather the log files—where theagent/sniffer entities are either not installed and/or not needed on theclient server 344.

FIGS. 4A-B illustrate approaches to implement the log collectionconfiguration. This approach allow for very large scale configuration ofhow to monitor log files having one or more log entries. In someembodiments, a log entry corresponds to a single logical row from a logfile. In the actual log file, a single entry could take multiple linesdue to carriage returns being part of the log entry content. This entirecontent is considered a single “entry”. Each entry starts with“####<date” and could occupy a single physical line in the file ormultiple lines separate by carriage returns.

In this model the “Log Type” 406 defines how the system reads the logfile, as well as how to decompose the log file into its parts. In someembodiments, a log file contains several base fields. The base fieldsthat exist may vary for different types of logs. A “base parser” can beused to breaks a log entry into the specified fields. The base parsermay also perform transformations. For instance, a Date field can beconverted to a normalized format and time adjusted to be in UTC so datafrom many locations can be mixed together.

The “Log Source” 404 defines where log files are located and how to readthem. In some embodiments, the log source is a named definition thatcontains a list of log files described using patterns, along with theparser that is needed to parse that file. For instance, one source couldbe “SSH Log files”. This source may list each log file related to SSHseparately, or could describe the log files using a wildcard (e.g.,“/var/log/ssh*”). For each pattern, a base parser can be chosen (e.g.,by a user) to parse the base fields from the file. This approach can beused to ensure that for a single pattern that all files conform to thesame base parse structure. For one source, one can choose from amongmultiple log types, and give a priority to those possible types. Forexample, types A, B, and C can be identified, where the analysis worksthrough each of these in order to determine whether the source matchesone of these identified types. Therefore, for each pattern, the user canchoose multiple base parsers. In some embodiments, the same source maymatch against and be analyzed using multiple types.

The “Log Rule” 402 defines a set of sources along with conditions andactions to be triggered during continuous monitoring. The “Targets” 408identify individual components in an IT environment that contain logs.Associating a rule to a target starts the monitoring process in someembodiments.

In the embodiment of FIG. 4A, one or more log rules are associated withone or more targets. In the alternative embodiment of FIG. 4B, one ormore log sources can be associated with one or more targets to create aninstance of a target. In the embodiment of FIG. 4C, log rules are noteven provided as an approach to create the associations—where only logsource to target associations are provided to create target instances.Each of these approaches are described in more detail below.

FIG. 5 shows a flowchart of an approach to implement a log collectionconfiguration by associating a log rule with a target. At 502, one ormore log rules are created. The rules are processed by a rules enginewithin the log processing system to implement rule-based handling of agiven target. Therefore, the rule will include specific logic forhandling a given target that it is associated with.

In some embodiments, the rule can be used to specific a target type,which identifies the type of the target that the rule is intended toaddress. A rule can be specified for a single target type or multipletarget types. For example, when monitoring a log file for a databaseinstance, the target type can be set to Database Instance so thatreporting of activities in the log goes against the proper target type;In some embodiments, even though the rule may be configured for a “File”as a log type, the target type can still be any managed target type,such as a database.

The rule may specify a source type, which identifies the type of logfile that the rule is intended to address. For example the rule mayspecify that the log file types will be: (i) File: OS level log file;(ii) Database Table: a table that stores log content in a database;(iii) Windows Event Log: read events from windows event as log content.

A target property filter may be specified in the rule to filter fortargets to specify conditions under which the rule is applicable, suchas for example, a particular operating system (OS), target version,and/or target platform. For instance, the user could create a rule thatis only for a given OS on a given platform (e.g., only for Linux OEL5 onX86_64 hardware).

When creating rules in some embodiments, the rule the may also include:(a) the name of the rule; (b) a severity level indicating how importantthe outcome of this rule is if this rule leads to an event beinggenerated; (c) a description of the rule; and/or (d) a textual rationaleof why this monitoring is occurring.

In some embodiments, one or more conditions can be established for whichthe rule will “trigger”. Multiple conditions may be specified, whereeach condition can be combined with others using a Boolean operator. Forexample, a set of conditions that is ORed with others means that if anyof these conditions match an entry in a log file under evaluation, thenthat entry triggers this rule. When the conditions are ANDed together,all clauses of the condition must be met for the condition to trigger anentry in a log file. The specified actions will then be taken as aresponse to this entry that is matched. The following is an examplecondition clause that includes a regular expression: “MESSAGE contains“START: telnet pid=[0-9]* from=[.]*””, where this condition triggers therule if the message matches the regular expression.

The “operator” in the condition is how the comparison is to beperformed. The following are some example operators that may be employedin some embodiments of the invention: (a)<, >, >=, <=: compare a valueto be larger or smaller (or equal) than some set value; (b) Contains:pattern match with ability to include regular expression clauses, wherean implicit wildcard may be placed at the beginning and end unless theuser uses the {circumflex over ( )} and $ regular expression symbols tospecify the beginning of a string or end of the string; (c) In: list ofpossible values; (d) Is: exact string match (no regular expressioncapability); (e) Is Not; (f) Does Not Contain; (g) Not In: List ofvalues to not match.

Actions may be specified to identify what to do when a match is found onthe selected sources for a given condition. For example, one possibleaction is to capture a complete log entry as an observation whenmatching conditions of the rule. This approach lets the system/user,when monitoring a log from any source and when a single entry is seenthat matches the conditions of this rule, to save that complete entryand store it in the repository as an observation. Observations arestored for later viewing through the log observations UI or otherreporting features. Another possible action is to create an event entryfor each matching condition. When a log entry is seen as matching thespecified conditions, this approaches raise an event. In someembodiments, the event will be created directly at the agent. The sourcedefinition will define any special fields that may be needed forcapturing events if there are any. An additional option for this actionis to have repeat log entries bundled at the agent and only report theevent at most only once for the time range the user specified. Thematching conditions can be used to help identify the existence of arepeat entry. Another example action is to create a metric for the ruleto capture each occurrence of a matching condition. In this approach, anew metric is created for this rule using a metric subsystem.Thereafter, when there is a log entry that matches the rule'sconditions, some number of the fields are captured as metric data anduploaded as part of this metric. The fields can be selected to include,for example, information such as “key” fields like target, time, source,etc.

At 504, one or more targets are identified in the system. The targetsare individual components within the customer environment that thatcontain logs. These targets are associated with specificcomponents/hosts in the customer environment. Example targets includehosts, database application, middleware applications, and/or othersoftware applications, which are associated with one or more logs one ormore hosts. More details regarding an approach to specify targets aredescribed below.

At 506, an association is made between a target and a rule. Metadata maybe maintained in the system to track the associations between a giventarget and a given rule. A user interface may be provided that allows auser to see what targets a selected rule is associated with and/or toadd more associations, where the associations are the way the rulebecomes active by associating the rule against a real target.

Thereafter, at 508, log collection and processing are performed based atleast in part upon the association between the rule and the target. Asdiscussed in more detail below, target-based configuration may involvevarious types of configuration data that is created at both theserver-side and the target-side to implement the log collection as wellas log processing.

The ability of the current embodiment to configure logcollection/monitoring by associating targets with log rules providesunique advantages. This is because the user that configures logmonitoring does not need to specifically understand exactly how the logsfor a given application are located or distributed across the differenthosts and components within the environment. Instead, the user onlyneeds to select the specific target (e.g., application) for whichmonitoring is to be performed and to then configure the rules underwhich the log collection process is to be performed.

This solves the significant issue with conventional systems that requireconfiguration of log monitoring on a per-host basis, where set-up andconfiguration activities need to be performed each and every time a newhost is added or newly configured in the system, or even where new logcollection/configuration activities need to be performed for existinghosts. Unlike conventional approaches, the log analytics user can beinsulated from the specifics of the exact hosts/components that pertainto the logs for a given target. This information can be encapsulated inunderlying metadata that is maintained by administrators of the systemthat understand the correspondence between the applications, hosts, andcomponents in the system.

Instead of, or in addition to the rules, log processing can also beconfigured by associating a log source to a target. FIG. 6 shows aflowchart of an approach to implement a log collection configuration byassociating a log source with a target. At 602, one or more log sourcesare created. The log source defines where log files are located and howto read them. The log source may define a source type that indicates howthe source content is gathered. The following are example source types:(a) File—identifies a readable file from the OS level that can beaccessed using regular OS-level file operations; (b) Database Table—atable that stores log entries (e.g.: database audit table); (c) WindowsEvent System—an API that provides access to event records. One or moresource names may be defined for the log source. In addition, the logsource may be associated with a description of the source. It is notedthat log sources can also be used when creating log monitoring rules (asdescribed above).

The log source may also be associated with a file pattern and/orpathname expression. For instance, “/var/log/messages*” is an example ofa file pattern (that may actually pertain to a number of multiplefiles). Regarding file patterns, one reason for their use in the presentlog analytics system is because it is possible that the exact locationof the logs to monitor varies. Some of the time, a system will expectlogs to be in a particular place, e.g., in a specific directory. Whenthe system is dealing with a large number of streaming logs, it may notbe clear which directory the logs are expected to be in. This prevents asystem that relies upon static log file locations to operate correctly.Therefore, the file pattern is useful to address these possibly varyinglog locations.

In some embodiments, a log source is created by specifying a source nameand description for the log source. The definition of the log source maycomprise included file name patterns and excluded file name patterns.The file name patterns are patterns that correspond to files (ordirectories) to include for the log source. The excluded file namepatterns correspond to patterns for files (or directories) to explicitlyexclude from the log source, e.g., which is useful in the situationwhere the included file name pattern identifies a directory havingnumerous files, and some of those files (such as dummy files or non-logfiles) are excluded using the excluded file name pattern. For eachpattern, the system captures the pattern string, the description, andthe base parser (log type) that will be used to parse the file. The baseparser may define the basic structure of the file, e.g., how to parsethe data, hostname, and message from the file.

The definition of the log source may also specify whether the sourcecontains secure log content. This is available so that a source creatorcan specify a special role that users must have to view any log data maybe captured. This log data may include security-related content that notany target owner can view.

As noted above, the log rules may reference log sources, and vice versa.In some embodiments, the system metadata tracks these associations, sothat a count is maintained of rules that are currently using sources.This helps with understanding the impact if a source and/or rule ischanged or deleted.

At 604, one or more targets are identified. As noted above, targets arecomponents within the environment that that contain, correspond, and/orcreate logs or other data to be processed, where the targets areassociated with specific components/hosts in the customer environment.Example targets include hosts, database application, middlewareapplications, and/or other software applications, which are associatedwith one or more logs one or more hosts.

At 606, an association is made between a target and a source. Metadatamay be maintained in the system to track the associations between agiven target and a given source. A user interface may be provided thatallows a user to see what targets a selected source is associated withand/or to add more associations.

The association of the target to the source creates, at 608, a specificinstance of the log source. For example, consider a log source thatgenerically specifies that a given file is located at a given directorylocation (e.g., c:/log_directory/log_file). It may be the case that anynumber of servers (Server A, Server B, Server C, Server D) within acustomer environment may have a copy of that file (log_file) in thatdirectory (c:/log directory). However, by associating a specific target(e.g., Server A) to the log source, this creates an instance of the logsource so that the new instance is specific regarding the log file inthe specified directory on a specific target (e.g., to begin monitoringc:/log_directory/log_file specifically on Server A).

Thereafter, at 610, log collection and processing are performed based atleast in part upon the association between the rule and the log source.As discussed in more detail below, target-based configuration mayinvolve various types of configuration data that is created at both theserver-side and the target-side to implement the log collection andprocessing activities.

There are numerous benefits when using this type of model forconfiguring log collection. One benefit is that the Log Types, Sources,Rules can be easily reused as necessary. In addition, this approachavoids having to make numerous duplicate configurations by enablingsharing at multiple levels. Moreover, users can create custom rules thatuse sources and log types defined by other people or ship with theproduct. This approach also easily builds on top of shared knowledge.

Associating rules/sources to targets provides knowledge that identifieswhere to physically enable log collections via the agents. This meansthat users do not need to know anything about where the targets arelocated. In addition, bulk association of rules/sources to targets canbe facilitated. In some embodiments, rules/sources can be automaticallyassociated to all targets based on the configuration. As noted above,out-of-the-box configurations can be provided by the service provider.In addition, users can create their own configurations, includingextending the provided out-of-the-box configurations. This permits theusers to customize without building their own content.

FIG. 7 shows a flowchart of an approach to implement target-basedconfiguration for log monitoring. This process generates the creation,deployment, and/or updating of configuration materials for logmonitoring. In some embodiments, configuration materials are embodied asconfiguration files that are used by the log monitoring system to manageand implement the log monitoring process.

At 700, target-based processing is initiated. Example approaches forinitiating target-based processing includes, for example, installationof a log analytics agent onto a specific log collection location. Thetarget-based processing pertains to associations made between one ormore targets and one or more log sources and/or rules.

At 702, configuration materials are generated for the target-basedprocessing. In some embodiment, the target-based configuration file isimplemented as configuration XML, files, although other formats may alsobe used to implement the configuration materials. The target-basedconfiguration file may be created at a master site (e.g., to create amaster version 704), with specific versions then passed to both theserver side and the target side.

The target-side materials 708 may comprise those portions of theconfiguration details that are pertinent for log collection efforts.This includes, for example, information about log source details andtarget details. The server-side materials 706 may comprise portions ofthe configuration details that are pertinent to the server-side logprocessing. This includes, for example, information about parserdetails.

In some embodiments, a database at the server maintains a master versionand a target version of the configuration materials. As noted above, thetarget version includes configuration details that are pertinent to logcollection efforts, and is passed to the customer environment to be usedby the agent in the customer environment to collect the appropriate logdata from the customer environment. The master version includes the fullset of configuration details needed at the server, and becomes the“server side” materials when selected and used for processing at theserver. This may occur, for example, when the log data collected at thetargets are passed to the server, where the transmission of the log dataincludes an identifier that uniquely identifies the target-sidematerials used to collect the log data (e.g., the configuration versionor “CV” number 903 shown in the example targets-side materials of FIG.9). When this data is received at the server, the identifier is used todetermine the corresponding master version of the materials that havethe same identifier number (e.g., as shown in field 1003 in the exampleserver-side materials of FIG. 10). That master version is then used asthe server-side materials to process the received log data. Therefore,in this embodiment, the master version 704 and the server-side materials706 are identical, but having different labels depending upon whetherthe material is currently in-use to process the log data. In analternative embodiment, the master version may differ from a serverversion, e.g., where the materials are used on multiple servers withdifferent configuration details.

At 710, the configuration materials are then distributed to theappropriate locations within the log processing system. In someembodiments, the target-side materials 708 are distributed to thecustomer system as the sniffer configuration files 332 shown in FIG. 3A.With regards to the server-side materials 706, the materials are“distributed” as the log configuration files 111 shown in FIG. 1A, wherethe distribution does not actually require the materials to bedistributed across a network, but merely indicates that the materialsare obtained from another component within the server (e.g., on anas-needed basis).

Thereafter, at 712, log collection processing is performed at the targetusing the target-side configuration materials. In addition, at 714,server-side log processing is performed using the server-sideconfiguration materials.

FIG. 8 shows a more detailed flowchart of an approach to implementtarget-based configuration for log monitoring according to someembodiments of the invention. At 802, one or more work items forprocessing target associations are created in the system. For example,this type of work may be created upon installation of the log analyticsagent onto a target, where recognition of this installation causes awork item to be created for the target-based configuration materials. Alist of target types are identified that have at least oneauto-association rule (e.g., from a database of the associations). Alist of targets is generated for which there is a need to be associatedwith auto-enabled rules. These steps are equivalent to puttingassociation tasks into a queue (e.g., database table) by a producerentity/process, which are then processed by one or more consumerentities/processes.

One or more consumer/worker entities may wake up periodically to processthe work items. For example, a worker entity (e.g., thread or process)wakes up (e.g., every 10 seconds) to check whether there are any pendingassociation tasks. The set of one or more workers will iterate throughthe tasks to process the work in the queue.

At 804, one of the workers identifies an association task to process. At806, the association request is processed by accessing informationcollected for the rules, sources, parsers, fields, and/or target. Thisaction identifies what target is being addressed, finds that target, andthen looks up details of the log source and/or log rule that has beenassociated with the target.

At 808, the worker then generate configuration content for the specificassociation task that it is handling. In some embodiments, theconfiguration content is embodied as XML content. This action createsboth the target-side details and the server-side details for theconfiguration materials. For the server-side, this action will createconfiguration data for the server to process collected log data. Forexample, parser details in XML, format are created for the server-sidematerials for the log data expected to be received. For the target-side,this action will create configuration data for log collection from thetarget. For example, as discussed below, variable pathnames (e.g.,having variables instead of absolute pathnames) may be specified for agiven log source to identify a directory that contains log files tomonitor. These varying pathnames may be replaced with actual pathnamesand inserted into the target-side materials at step 808.

A determination is made at 810 whether there are any additionalassociation tasks to process. If there are additional tasks on thequeue, then the process returns back to 804 to select another task toprocess. If not, then at 812, the configuration materials are finalized.

It is noted that the same configuration/XML file can be used to addressmultiple associations. For example, if multiple targets are on the samehost, then a single configuration file may be generated for all of thetargets on the host. In this case, step 808 described above appends theXML, content to the same XML, file for multiple iterations through theprocessing loop.

Updates may occur in a similar manner. When a change occurs thatrequires updating of the materials, then one or more new associationtasks may be placed onto a queue and addressed as described above.Furthermore, de-associations may also occur, e.g., where the loganalytics agent is de-installed. In this situation, the configurationfiles may be deleted. When a target is deleted, a message may bebroadcast to notify all listeners about this event by a target modelservice, which may be consumed to delete the corresponding associationsand to update the XML content.

FIG. 9 illustrates example XML configuration content 900 according tosome embodiments of the invention. This is an example of target-sidecontent that may be placed on the host that holds the target. This XMLconfiguration content 900 defines a rule to collect Linux system messagelogs with file pattern “/var/log/messages*” on host XYZ.us.oracle.com.Portion 902 identifies a base parser for the association beingaddressed. Portion 903 provides an identifier for the version number(“configuration version” or “CV”) of the content 900, which is used tomatch up against the corresponding server-side materials having the sameversion number. Portion 904 identifies the ID of a log rule. Portion 906identifies a specific target. Portion 908 identifies a target type.Portion 910 identifies a source type. Portion 912 identifies a parser IDfor the source. The logs will be parsed based on some defined parser.Such configuration files reside on sniffers and the log collectionprocesses collect logs based on the defined log sources.

In the log processor at the server side, additional information can beincluded in the configuration file to facilitate the log parsing, e.g.,as shown in the server-side content portion 1000 of FIG. 10. TheFieldDef portion 1001 indicates the data type for the service. The LogSource portion 1002 indicates the logs are of “os_file” type. TheBaseParse portion 1004 defines the way to parse the log entries based ondefined regular expressions in portion 1006. Portion 1003 provides anidentifier for the version number of the content 1000, which is used tomatch up against the corresponding target-side materials having the sameversion number.

In addition to the above-described auto-associations, target-sourcemanual associations may also be performed. For example, a user interfacemay be provided to perform the manual associations. This also causes theabove-described actions to be performed, but is triggered by the manualactions.

Re-synchronization may be performed of target-source associations. Toexplain, consider that when a log analytics agent is installed,monitored targets connected through the agent can be associated withcertain pre-defined log sources Similarly, when the agent isde-installed, such associations can be deleted from the appropriatedatabase tables. In addition, when a target is added to be monitored byan agent, the target can be associated with certain pre-defined logsources for that target type, and when the target is deleted from anagent, such association can be deleted from database tables.

Over time, these associations could become out-of-sync due to variousreasons. For example, when a log analytics agent is being installed, theauto-association may occur due to some network issue that causes theloss of the configuration materials during its transfer. In addition,when a target is added or deleted, an event may not processed properlyso the configuration XML, file when updating does not occur asappropriate.

To handle these cases and maintain the association consistency betweentargets and their corresponding log sources, a web service is providedin some embodiments to synchronize the associations periodically. In atleast one embodiment, only the auto-associations are synched, and notthe manual associations customized by users manually.

Associations may be performed for a specific log analytics agent. Adelta analysis can be performed between targets in a data model datastore and targets in a log analytics data store to implement thisaction. Processing may occur where: (a) For targets in data model datastore but not in log analytics data store, add associations for thesetargets; (b) For targets not in data model data store but in loganalytics data store, delete associations for these targets; (c) Fortargets in data model data store and log analytics data store, keep thesame associations for these targets in case of user customization. Onepotential issue for adding associations pertains to the situation wherea user may have deleted all associations for a particular target sothere is no entry in the log analytics data store, but there is an entryin the data model data store. The issue is that when applying the aboveapproach, the auto-associations not wanted could be brought in againafter the synchronization operation. To avoid this, the system canrecord the user action to identify the potential issue.

In addition, associations may be synchronized for a specified tenant.When this action is performed, delta analysis can be performed betweenthe agent for the data model data store and agent for the log analyticsdata store. Processing may occur by: (a) For an agent in the data modeldata store but not in the log analytics data store, add associations forthese agents; (b) For agents not in the data model data store but in thelog analytics data store, delete associations for these agents; (c) Foragents in the data model data store and the log analytics data store,perform the same delta analysis and synchronization as described above.

Synchronization may be performed for associations for all tenants. Whenthis action is performed, it should perform agent-level synchronizationas described for each tenant.

Turning the attention of this document to file patterns, one reason fortheir use in log analytics systems is because it is possible that theexact location of the logs to monitor varies. Most of the time, a systemwill expect logs to be in a particular place, in a specific directory.When the system dealing with a large number of streaming logs, it maynot be clear which directory the logs are expected to be in. Thisprevents a system that relies upon static log file locations fromoperating correctly.

The inventive approach in some embodiments can associate log analysisrules to variable locations. One approach is to use metadata thatreplaces variable parts that correspond to locations for the log files.A path expression is used to represent the pathname for the log files,where the path expression includes a fixed portion and a varyingportion, and different values are implemented for the variable part. Theplaceholder for location is eventually replaced with the actual locationin the directory path.

Some embodiments provide for “parameters”, which are flexible fields(e.g., text fields) that users can use in either the include file namepatterns or exclude file name patterns. The parameters may beimplemented by enclosing a parameter name in curly brackets {and}. Auser-defined default value is provided in this source. A user can thenprovide a parameter override on a per target basis when associating alog monitoring rule using this source to a target. The overrides areparticularly applicable, for example, with regards to changes fromout-of-the-box content (e.g., to override rules, definitions, etc.without actually changing the OOTB content). This is implemented, forexample, by implementing a mapping/annotation table that includes theuser overrides and indicate of an override for the OOTB content.

The reason this is very helpful is because in the log sources, paths maybe defined for log files to monitor. In some cases, the paths are fixed,such as in the Linux syslog file, the path is “/var/log/messages*”.However, in other cases, one may want to monitor a database alert log,where each database target will be installed in a completely differentpath, and the path to find the alert log may be different. For example,the alert log for one database is located at this location:“/xxx/db/yyyy/oracle/diag/rdbms/set2/set2/alert/log*.xml”. Theunderlined portions may vary for every database target. However, eachtarget has the notion of target properties. Included in these propertiesare metadata that can be used to fill in the variable parts in the path.In the current embodiment, one can express this path instead as:“{DIAGNOSTIC_DEST}/diag/rdbms/{SID}/{SID}/alert/log*.xml”

When this source is used in a rule and this rule is associated to thetarget, the system replaces the parameters “DIAGNOSTIC_DEST” and “SID”with those that are known for that target. This allows the system toassociate a single rule and source to thousands of targets at once.

As another example, the user may want to monitor the pattern:“/xxx/oracle/log/*”. In this case, “/xxx/oracle” is a variable pathdepending on the host. One could instead write the pattern as:“{INSTALL_DIR}/log/*”. For this source, the user can provide a defaultvalue (/xxx/oracle) to the INSTALL_DIR parameter. Later, when rule isassociated to a target, the user can provide a target override value of“/xxx/oracle” for this parameter on this target without having to createa new source or rule.

With regards to system-defined fixed parameters, there may be a casewhere the user wishes to reference a built-in parameter (e.g.,ORACLE_HOME). Here, the system will replace that variable with theORACLE_HOME that is known for the selected target. The pattern could bewritten as: “{ORACLE_HOME}/log/*”. This path will automatically beunderstood by the agent, where ORACLE_HOME is a special built-inparameter that does not need a default to be set by the user. The systemcould be provided with a list of fixed parameters that integrators/userscan choose to use.

FIG. 11 shows a flowchart of one possible approach to implement thisaspect of some embodiments of the invention. At 1102, identification ismade of location content for which it is desirable to implement variablelocation processing. This situation may exist, for example, when thesystem is handling a large number of streaming logs from possibly alarge number and/or uncertain of directory locations. The log data maybe located at target locations that are addressed using a pathname thatvaries for different database targets.

At 1104, a path is specified for the target locations having a fixedportion and a varying portion. The varying portion may be representedwith one or more parameters. During log processing, at 1106, the one ormore parameters are replaced with values corresponding to one or moretarget log files, wherein a single rule for implementing log monitoringis associated with multiple different targets to be monitored.

This approach is quite advantageous over approaches where every log isin a different directory that one cannot know about ahead of time, andwhere a separate forwarder mechanism would have to be set up for eachpath. Instead, the present approach can be used to set up one rule for avery large number of paths.

In some embodiments, configuration information from the log analyticssystem can be coupled to this approach to configure and setup the rulesfor identifying log file assignments. Some examples of configurationinformation that can be used include, for example, how a database isconnected, how the components are connected, which datacenter is beingused, etc.

Some embodiments specify how to map sources to targets based on theirrelationships. For instance, a defined source Source1 can be assigned toall related targets belonging to a certain system. Any association typeand/or rule can be used in this embodiment, e.g., where a common set ofassociation types is used to provide configuration information usefulfor determining rules for log locations. Such association types mayinclude, for example, “contains”, “application_contains”,“app_composite_contains”, “authenticated_by”, “composite_contains(abstract)”, “cluster_contains”, “connects_through”, “contains(abstract)”, “depends_on(abstract)”, “deployed_on”, “exposes”,“hosted_by”, “installed a “managed_by”, “monitored_by”, “provided_by”,“runs_on (abstract)”, “stores_on”, stores_on_db” and “uses (abstract)”.

It is noted that the target relationship information/model can be usedin other ways as well. For example, the target model can also be used tohelp correlate log entry findings to aid in root cause analysis. Asanother example, the host model can be used for comparing all hosts inone system. For instance, if there are a number of databases in a firstsystem, this feature can be used to see logs across these systemstogether, and in isolation from databases used for a second system.

FIG. 12 illustrates an architecture for implementing some embodiments ofthe inventive approach to associate log analysis rules to variablelocations. Here, the log analytics engine 1202 operates by accessing logcollection configuration files 1211. Log collection configuration files1211 is implemented to represent a path where the target location mayhave both a fixed portion and a varying portion. The varying portion maybe represented with one or more location parameters. In this example,different locations may exist for logs 1201 a, 1201 b, and 1201 c. Byreplacing the variable portion, the specific location for the log ofinterest may be selected by the log analytics engine 1202, and processedto generate analysis results 1213.

Here, the reference material 1210 may be accessed to identify thecorrect replacement of the variable portions of the paths for the targetlocations. Any suitable type of reference materials may be implemented.As noted above, a defined source Source1 can be assigned to all relatedtargets belonging to a certain system, and/or an association type and/orrule can be used as well. In addition, target relationshipinformation/models can be employed as well as the reference material.

Embodiments of the invention therefore provides improved functionalityto perform target-based log monitoring. Two possible use cases thisfunctionality includes log monitoring and ad hoc log browsing. Logmonitoring pertains, for example, to the situation where there iscontinuous monitoring and capture of logs. Some embodiments of logmonitoring pertains to the some or all of the following: (a) monitor anylog for any target and capture significant entries from the logs; (b)create events based on some log entries; (c) identify existence of logentries that can affect a compliance score; (d) perform user as well asintegrator defined monitoring; (e) capture log entries that are notevents to enable analytics on a subset of all logs; (f) use cases suchas intrusion detection, potential security risk detection, problemdetection; (g) implement long term persistent storage of log contents;(h) search for log content; (i) customizable search-based views; (j) loganomaly detection and scoring

Ad hoc log browsing pertains, for example, to the situation where thereis not continuous monitoring of logs. In this approach, the user canbrowse live logs on a host without having to collect the logs and sendthem up to the SaaS server. The model for configuring what to monitor issimilar to what was described earlier. The difference pertains to thefact that the user can select a rule, source, and some filters from theUI and the search is sent down to agent to obtain log files that matchand bring them back, storing them in a temporary storage in the server.The user can continue to narrow their search down on that result set. Ifthe user adds another target, rule, or extends the time range, thesystem goes back to the agent to obtain only the delta content, and notthe entire content again. The user can therefore get the same benefitsof log analytics without configuring continuous log monitoring. Thefeature can be very low-latency since the system only needs to go backto get more data from agent when the search is expanded. All searchesthat are narrowing down current result set goes against the data thathave been cached from a previous get from the agent.

The embodiments of the invention can be used to store log data into along-term centralized location in a raw/historical datastore. Forexample, target owners in the company IT department can monitor incomingissues for all responsible targets. This may include thousands oftargets (hosts, databases, middle wares, and applications) that aremanaged by the SaaS log analytics system for the company. Many logentries (e.g., hundreds of GB of entries) may be generated each day. Forcompliance reasons, these logs may be required to be stored permanently,and based on these logs, the data center manager may wish to obtain somebig pictures of them in long run and IT administrators may wish tosearch through them to figure out some possible causes of a particularissue. In this scenario, a very large amount of logs could be stored ina centralized storage, on top of which users can search logs and viewlog trends with acceptable performance. In some embodiments, the logdata can be stored in an off-line repository. This can be used, forexample, when data kept online for a certain period of time, and thentransferred offline. This is particularly applicable when there aredifferent pricing tiers for the different types of storage (e.g., lowerprice for offline storage), and the user is given the choice of where tostore the data. In this approach, the data may held in offline storagemay be brought back online at a later point in time.

The logs can be searched to analyze for possible causes of issues. Forexample, when a particular issue occurs to a target, the target ownercan analyze logs from various sources to pinpoint the causes of theissue. Particularly, time-related logs from different components of thesame application or from different but related applications could bereported in a time-interleaved format in a consolidated view to helptarget owner to figure out possible causes of the issue. The targetowner could perform some ad-hoc searches to find same or similar logentries over the time, and jump to the interested log entry, and thendrill down to the detailed message and browse other logs generatedbefore/after the interested point.

In some embodiments, restrictions can be applied such that users haveaccess only to logs for which access permissions are provided to thoseusers. Different classes of users may be associated with access todifferent sets of logs. Various roles can be associated with permissionsto access certain logs.

Some embodiments can be employed to view long-term log distribution,trends, and correlations. With many logs generated by many differenttargets and log sources over long time, data center managers may wish toview the long-term log distributions and patterns.

Some embodiments can be employed to search logs to identify causes of anapplication outage. Consider the situation where an IT administrator ortarget owner of a web application receives some notification that somecustomers who used the application reported that they could not completetheir online transactions and the confirmation page could not be shownafter the submit button was clicked. With embodiments of the invention,the IT administrator can search the logs generated by the applicationwith the user name as key and within the issue reporting time range.Some application exception may be found in the log indicating that somedatabase error occurred when the application tried to commit thetransaction. By adding the database and its corresponding hosting servervia target association relationship and their availability related logsources for the search, the IT administrator could browse the logsaround the application exception time to find some database errors,which was related for example to some hosting server partial diskfailure and high volume of committing transactions.

Some embodiments can be employed to view long-term log distributions,trends, and correlations by tags. A data center manager may define sometags for logs collected in the data center, such as security logs forproduction databases, security logs for development servers, logs fortesting servers, noise logs, etc. The data manager may be interested,for example, in knowing the followings: log distributions by these tagsover the past half year, their daily incoming rates during last month,and whether there are any correlations between the security log entriesfor production databases and the changes of their compliance scoresduring a given time period.

Some embodiments permit log data to be stored as metrics. In certainembodiments, the system will store several log fields as key fields. Thekey fields will include (but may not be limited to): Time, Target, Rule,Source, and Log File. The system may also create a hash or GUID todistinguish possible log entries that have the same time and all otherkey fields. When a rule that is using this metric action for log entriesis associated with the first target, a metric extension is created anddeployed. This metric extension will be named similar to the rule tomake it easy for the user to reference it.

In some embodiments, the log monitoring rule has a possible action tocreate an event when a log entry matches the condition of the rule.Additionally, users will be able to indicate that this event should alsotrigger a compliance violation which will cause an impact on thecompliance score for a compliance standard and framework.

As noted above, one possible use case is to provide a log browser, e.g.,where browsing is employed to browse live logs on a host withoutcollecting the logs and sending them to a SaaS Server. The user canselect a rule, source, and some filters from the UI and the search issent down to agent to obtain log files that match and bring them back,storing them in a temporary storage in the server. One use case for thisfeature is to allow users to browse a short time period of log filesacross multiple targets in a system to try to discover a source of aproblem, especially when there is a rich topology mapping and dependencymapping of the customer's environment. This content can be used to helpfind related elements and show the logs together. This allows the usersto see logs for all targets related to a given system for instance andsee what happened across all targets in time sequence. In many cases,when there is a target failure, it may be a dependent target that isexperiencing the problem, not the target that is failing.

The user may choose to start a new log browsing session in context of asystem/group/individual target. If coming in from a target home page,the target home page context is to be retained. This means that theouter shell of the page still belongs to the target home page, and justthe content panel will contain the browse UI functionality. This meansthe browse UI can be implemented to be modular to plug into other pagesdynamically. In some embodiments, multiple row-content can be providedper entry to show additional details per row. This is one row at a time,or the user could decide to perform this for all rows. Sorting can beprovided on the parsed fields, but in addition, can be used to seeadditional details per row (including the original log entry).

Search filters can be provided. For example, a search filter in the formof a date range can be provided, e.g., where the options are MostRecent, and Specific Date Range. With the Most Recent option, the usercan enter some time and scale of Minutes or Hours. With the SpecificDate Range, the user will enter a start and end time. With the daterange option, Targets, Sources, and Filters can be specified. Theseallow the users to select what they want to see in this log browsingsession. After the user has selected the targets, sources, and appliedany filters, they can begin the browse session to initiate retrieval ofthe logs from various targets and ultimately have them shown on theinterface.

Search queries can be implemented in any suitable manner. In someembodiments, natural language search processing is performed toimplement search queries. The search can be performed across dependencygraphs using the search processing. Various relationships can be queriedin the data, such as “runs on”, “used by”, “uses”, and “member of”.

In some embodiments, the search query is a text expression (e.g., basedon Lucene query language). Users can enter search query in the searchbox to search logs. The following are example of what could be includedin the search query: (a) Terms; (b) Fields; (c) Term modifiers; (d)Wildcard searches; (e) Fuzzy searches; (d) Proximity searches; (f) Rangesearches; (g) Boosting a term; (h) Boolean operators; (i) Grouping; (j)Field grouping; (k) Escaping special characters.

A tabular view can be provided of the search findings. Some queryrefinement can be performed via table cells to allow users to add/removesome field-based conditions in the query text contained in the searchbox via UI actions. For example, when a user right-mouse clicks a field,a pop-up provides some options for him/her to add or remove a conditionto filter the logs during the searches. This is convenient for users tomodify the query text, and with this approach, users do not need to knowthe internal field names to be able to refine the query at field level.

There are numerous ways that can be provided to list fields for user toselect/de-select them for display purpose in the search findings table.One example approach is based on static metadata, and another possibleway is based on dynamic search results.

For list fields based on static metadata, a basic field shuttle is usedto list all defined fields. Some example fields that can be defined bythe log entry metadata include: (a) Log file; (b) Entry content; (c)Rule name; (d) Source name; (e) Parser name; (f) Source type; (g) Targettype; (h) Target name. The values of these fields can be obtained fromthe agent with log entry (although source, parser, rule, target are allGUIDs/IDs) that will need to be looked up at display time.

For list fields based on dynamic search findings, the top n fields(e.g., 10) will be shown that would be suggested as making the mostdifference for that search. A “more fields” link will lead to a popupfor users to select other fields. Users can see more information ofthose fields on the popup than form the View menu. When listing thefields, the system could use any suitable algorithm, for example, toassign a number to each field that is influenced by how many rows in thesearch results having non-null value, or how many different values thereare across all search results for that field, etc.

Given so many dynamic fields available for users to select/de-select, itis desired for a user to be able to save the fields selection (fieldnames and sizes). The system can store the last selected fields so whenthe user comes back to the page, he/she still gets the fields pickedlast time.

There may be a very large number (e.g., thousands) of log entriesresulting from a search and it may not be possible for users to browseall of them to find the interested logs. For a particular search, usersshould be able to drill down to the details of the search findings witha few clicks. In some embodiments, features include clickable bar chartsand table pagination. With these navigation features, plus customizabletime range, users should be able to jump to some interested pointquickly. Correspondingly, some embodiments provide for drilling up fromdetails to higher levels so users can easily navigate to desired logentries via bar graphs. An example use case is: after users drill down afew levels they may want to drill up back to a previous level to go downfrom another bar. After users identify an interested log entry via somesearches, they likely want to explore logs from a particular log sourcearound the interested log entry, or explore logs from multiple logsources around the interested log entry in time-interleaved pattern.Some embodiments provide an option for users to browse forward/backwardthe logs around a specified log entry page by page. A graphical view canbe provided of the search findings. This allows the user to pick fieldsto render the results graphically.

Some embodiments pertain to improved techniques to address logdistributions, trends, and correlations. For search findings resultedfrom a particular search, distributions can be based on log counts togive users some high-level information about the logs. For eachdistribution type, the top n (e.g., 5 or 10) items are listed withnumber of found logs (where a “more . . . ” link will lead to a popupwith all other items listed). When users select a particular item, onlylogs corresponding to that item would be shown in the right table, sothe action is equivalent to filtering the search findings with thatitem. Such information may be presented: (a) By target type; (b) Bytarget, such as target owner and/or lifecycle status; (c) By log source;(d) By tag. Besides showing the search findings in the results table,the system can also provide options for users to switch between tableview and the corresponding distribution chart view.

In some embodiments, results can be filtered by selecting distributionitems. Users can filter the results table by selecting one or moredistribution items. By default, all distribution items are selected andall log entries are listed in the results table. After selecting one ormore distribution items, users can navigate the log entries viapagination. With one or more distribution items selected, when usersclick the search button for a new search, the selections of distributionitems will be reset to be selected for all distribution items.

Some embodiments provide a feature to show search finding trends. Someembodiments provide a feature to show search finding correlations.Related to this feature, some embodiments provides launching links forusers to navigate to search/view detailed logs when they performcorrelation analysis among events, metrics, and infrastructure changes.Launching links could be provided, e.g., for users to navigate to an ITanalytics product to analyze/view detailed events/metrics when they wishto see some bigger pictures related to the logs here.

Another feature in some embodiments pertains to process-time extendedfield definitions. Even with the same baseline log type, it is possiblefor individual log entries to contain inconsistent information from onelog to the next. This can be handled in some embodiments by definingbase fields common to the log type, and to then permit extended fielddefinitions for the additional data in the log entries.

To explain, consider that a source definition defines log files tomonitor. The log files are parsed into their base fields based on thelog type definition. One can extract additional data that is notconsistent across all log entries, e.g., as shown in 1300 of FIG. 13. Inthis figure, the base fields that are parsed from the log entries areMonth, Day, Hour, Minute, Second, Host, Service, Port (optional), andMessage. The goal is to extract IP address and Port out of the secondlog entry. This goal may not be obtainable in certain implementations aspart of the log type, e.g., since not every log entry has thisstructure. Here, the Message field for the second entry has thefollowing content:

Accepted publickey for scmadm from xxx.xxx.1.1 port xyz ssh2

In some embodiment, a definition is made for an Extended FieldDefinition on the Message field using a format such as:

Accepted publickey for .* from {IP Address} port {Port} ssh2

For that log entry, two new field IP Address and Port will be parsed outand will be usable for reporting, searching, etc. This extractionhappens as the data is being processed at collection time.

According to some embodiments, the processing for implementingprocess-time extended field definitions comprises: identifying one ormore log files to monitor, wherein some of the entries in the one ormore log files may include additional data that does not exist in otherentries or is inconsistent with entries in the other entries, such as anadditional IP address field in one entry that does not appear in anotherentry; identifying a source definition for one or more log files tomonitor; parsing the one or more log files into a plurality of basefields using the source definition; defining one or more extended fieldsfor the one or more log files; and extracting the one or more extendedfields from the one or more log files.

Therefore, some embodiments permit the user to add extended fielddefinitions. These are defined patterns that are seen within a field. Auser could perform a create-like on a source and then the source and allextensions will become a new user-created source. The extended fielddefinition defines new fields to create based on the content in a givenfile field. In some embodiments, the extended field definitions (andtagging) can be applied retroactively. This allows past log data to beprocessed with after-defined field definitions and tags.

FIG. 14 shows some example field definitions 1302. For the first case inthe table, the user is specifying to look at the “Message” file fieldthat comes from the log entry and is parsed by the file parser. ThisMessage field will have text in it, but the user has identified thatthey want to capture the SIGNALNAME part of the message as a new fieldfor this specific message. This new field (SIGNALNAME) can now becomeviewable in the captured log entries, viewable in the Log Browser, andcan also be stored as part of a metric if a rule is created to do so.The extended field definition uses the entire contents of the Message inthis example. The user could bind either side of their expression with awildcard pattern. For instance, the definition could have been simply“sending a {SIGNALNAME}”. The text that is shown is known to be statictext that never changes for this log message. The use of [0-9]* in theexpression means that any number of numeric characters can be locatedhere, but they will just be ignored (since there is no field nameassociated to name this field. The text that comes after the string“sending a” will get assigned to the variable SIGNALNAME.

The last entry is another example where the user has defined two newfields and in the first field, they have also defined the way to getthis content using a regular expression. Here, there are some characterscontaining a-z, A-Z, 0-9 or a hyphen before a period ‘.’. Everythingthat matches that expression should be added to a new extended fieldcalled the HOSTNAME. Anything after the first period will be put into anew extended field called DOMAINNAME. The HOST field which came from thefile parser will still have all of the content, but this extended fielddefinition is telling our feature to add two NEW fields in addition tothe HOST field (HOSTNAME and DOMAINNAME).

All extended field definitions where a new field is defined using the {} delimiters uses a parse expression. However in this example, exceptthe HOSTNAME field in the last example, there is none shown. This isbecause in some embodiments, there is a default known regular expressionpattern of (.)* which means any number of character. This expression isimplicitly used if the user does not provide a regular expression. Ifthere is static text, the system will take any characters between thetwo pieces of static text. If there is no static text or charactersafter a field expression, it is assumed that every character to the endof the file field is part of the new extended field's value (likeDOMAINNAME in the last example and CONTENT_LENGTH_LIMIT in the thirdexample.) This could lead to some issues if there were variants of thislog entry that have additional text sometimes. The way to solve this isto also define the parse regular expression for each field and not relyon the default implicit (.)*.

Some embodiments provide the ability to define regular expressions andsave them with a name. For instance, the regular expression for hostnameused above is [a-zA-Z0-9\−]+.

One example of a saved regular expression may be:

-   -   IP_Address Regular        Expression=>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}        When referencing this saved regular expression in the extended        field definition, the last entry in the table above may look        like this instead:    -   {HOSTNAME:@IP_Address}.{DOMAINNAME}        The new fields that will be created are HOSTNAME and DOMAINNAME.        The referenced regular expression that was created and saved is        called IP_Address. When the system performs the processing on        the agent, it will replace the referenced regular expression        “@IP_address” with the regular expression string:    -   “\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}”

Extended expression definitions can be evaluated at the agent (e.g.,using a Perl parsing engine) directly with minor changes to the inputstring from the user.

In some embodiments, field reference definitions can be provided. Thisprovides a feature where users can provide a lookup table of a SQL queryto transform a field which may have a not-easily-readable value intomore human readable content. Three example use cases highlight thisneed: (a) In a log entry, there may be an error code field (either acore field or an extended field) that simply has a number, where theuser can provide a lookup reference so that the system adds another newfield to store the textual description of what this error code means;(b) In a log entry, there may be a field (either a core file field or anextended field) that has the GUID of a target, and the system canprovide a lookup using a SQL query to a target table that will createanother new field that stores the display name of the target; (c) IP tohostname lookup may also be performed as a common use case, where in alog, there may be IP addresses for clients, where the IP addresses areused to look up hostnames.

As noted above, log types (also referred to herein to include “Parsers”in some cases in this document) may also be defined to parse the logdata. One example log type pertains to the “Log Parser”, which is theparser that can be used to parse the core fields of the source. Anotherexample log type pertains to a “Saved Regular Expressions”, which can beused when defining extended field definitions. For example, a hostnamecan be defined via a regular expression as “[a-zA-Z0-9\−]+”. Thisregular expression can be saved with a name and then used a later timewhen creating extended field definitions.

A log parser is a meta-data definition of how to read a log file andextract the content into fields. Every log file can be described by asingle parser to break each log entry into its base fields. The log typemay correspond to a parse expression field, such as for example, a Perlregular expression for parsing a file. When defining a log parser, theauthor identifies the fields that will always exist in the log file. Inthis case, the following are the fields that exist in every entry of theabove log file:

Some fields may be very complex, meaning that the field will actuallycontain additionally structured content for some log entries but not forothers. These may not be handled by the log file parser in someembodiments because it is not consistent in every line. Instead, whendefining a source, extended fields can be defined to break this fieldinto more fields to handle these cases.

Profiles can be implemented for various constructs in the system, suchas parsers, rules, and sources. The profiles capture differences betweendifferent usages and/or versions of data items and products for users.For example, a source profile can be created that accounts for differentversions of a user's products that are monitored, e.g., where a sourceprofile changes the source definition between version 1 and version 2 ofa database being monitored. Rule profiles may be used to account fordifferences in rules to be applied. As another example, parser profilescan be provided to adjust parsing functionality, e.g., due to differencein date formats between logs from different geographic locations.Different regular expressions can be provided for the different parserprofiles.

With regards to a log entry delimiter, log files can have content thatis always known to be one row per entry (syslog), or can have contentthat can span multiple lines (Java Log 4j format). The Log EntryDelimiter input lets the user specify to always parse this log file asone row per entry, or to provide a header parse expression that tells ushow to find each new entry. The entry start expression will typically bethe same as the first few sections of the parse expression. The systemuses this expression to detect when a new entry is seen versus seeingthe continuation of the previous entry.

For this example, the entry start expression may be:

([A-Z]{1}[a-z]{2})\s([0-9]{1,2})\s([0-9]{1,2}):([0-9]{2}):([0-9]{2})

This expression looks for a strict month, day, hour, minute, secondstructure. If that exact sequence of characters is seen, this “line” istreated as the beginning of a new entry.

In some embodiments, a table is maintained corresponding to parsedfields, and which starts empty (no rows) as the parse expression isempty. As users are creating the parse expression, the fields beingdefined are added to this table. This can be implemented by monitoringthe text entered in this field and when a ‘)’ is added, a function iscalled to determine how many fields have been defined. The system canignore some cases of (and), e.g., when they are escaped or when they areused with control characters.

For instance, consider the following parsing language:

-   -   ([a-z] {2})\s([a-z0-9]+)

In this example, there are two pairs of ( ) which means there are twofields defined. The content inside is how to find the field from the logentry—The UI for this create parser page does not care about what isinside the parenthesis. This is evaluated and used on the agent only.The content outside of the (and) are just static text that helps parsethe line (this UI also does not care about this). For creating the rightnumber of fields in the table, the approach counts the number of ( )pairs in the parse expression. For each field that is parsed out by theparse expression, the user provides a field name based on one of theexisting common fields.

Automated Classifications

Some embodiments of the invention provide an approach to perform machinelearning-based classification of logs. This approach is used to grouplogs automatically using a machine learning infrastructure. The generalidea is that given the data from within logs to be analyzed, one canautomatically group the logs into appropriate categories (e.g., toautomatically identify the log type for the log).

FIG. 15 shows an architecture for performing machine learning-basedclassification of logs according to some embodiments of the invention. Aknown set of logs is acquired to form a baseline set of data for loggroupings, where the known set of logs are used to form learning models1505 a and 1505 b. The learning models 1505 a and 1505 b identifycharacteristics of known log types, so that unknown logs 1501 a-c thatare received can be matched against those characteristics to classifythose logs within one of the known log types.

Logs 1501 a-c are gathered from one or more computer readable mediums1503 within a customer environment. The logs 1501 a-c may undergofiltering by a filter 1502. Within the filter 1502, known patterns ofcontent are removed from the log data prior to classification. Forexample, it may be desirable to remove certain types of log contentexceptions (such as Java exceptions) from the log data prior toclassification. Therefore, one or more content patterns that correspondto a Java exception may be used to filter our any Java exceptions fromthe logs 1501 a-c.

Within a machine learning infrastructure 1504, a set of classifiers 1504a and 1504 b use the learning models 1505 a and 1505 b, respectively, toclassify the logs 1501 a-c. In some embodiments of the invention,multiple classifiers 1504 a and 1504 b are employed to classify the logs1501 a-c. The idea is that each classifier operates with a different setof parameters and assumptions from the other classifiers. By usingmultiple classifiers, this ensures that a corner case that maynegatively affect the accuracy of one classifier would not completelydestroy the ability to confidently generate a classification, since oneor more other classifiers not significantly affected by the corner casewould also be operating to classify the data. Careful selection of thetwo classifiers should allow the classification architecture 1504 toavoid misclassifications due to such data skews by all the classifiers,even if one of the classifiers may be affected.

In some embodiments, a first classifier, referred to herein as a“distribution classifier”, may operate based upon vectors generated bythe distribution/frequency of characters within the log. A secondclassifier, referred to herein as a “token classifier”, may operatebased upon vectors generated by identification of certain tokens withinthe log. A third type of classifier may operate by matching log contentagainst one or more regular expressions, where a given log type ofassociated with one or more regular expressions. For example, a certainlog type may always include the following in each log entry:“Name=[alphabetic name]”. In this case, the regular expression“Name\=[a-z]+” may be used to match against any logs that correspond tothis log type. A fourth type of classifier may operate by checking for apattern signature, where a given pattern signature corresponds to agiven log type. The pattern signature may be expressed, for example, byidentifying both fixed and variables portions, and checking whether thelog data matches against that signature. A simple example of a signaturecould be “Name=[variable portion] Date=[Variable portion]”, where the“Name=” and “Date=” sections of this line are fixed portions, andclassification operates by checking for this signature pattern within anunknown log.

While certain example classifiers are described above, it is noted thatother classifier types may also be employed within the scope of theinvention. In addition, while FIG. 15 only shows two classifiers used inconjunction with one another, it is noted that the inventive conceptdescribed herein may be applied with any number of classifiers, and isexpressly not limited just to two classifiers.

Assume that classifier 1504 a is a distribution classifier andclassifier 1504 b is a token classifier. Each unknown log within logs1501 a-c is processed to generate a vector for that log, e.g., byidentify term frequencies within the log for a distribution classifierand token-based vectors for a token classifier. The vector(s) are thencompared against the data within the learning models 1505 a and 1505 bfor the known set of logs. A similarity comparison is then performed toclassify the log and to generate classification results 1510.

FIG. 16 shows a high level flowchart of an approach to implement machinelearning-based classification of logs according to some embodiments ofthe invention. At 1602, the process begins with a training phase togenerate learning models for the classification process. As described inmore detail below, a supervised training process is performed toimplement the training phase.

Next, at 1604, the log data to be classified is gathered. As describedabove, one or more log gatherers may be located within the clientenvironment to gather the log data. The log data is gathered and passedto a log analytics system that includes the machine learninginfrastructure for classifying logs.

At 1606, the gathered log data is analyzed relative to the learningmodels, where content within the log data is vectorized to generate oneor more vectors. The vectors are then compared against the data withinthe learning models. In some embodiments, multiple classifiers mayoperate against the vectorized data. Based upon this analysis, at 1608,classification is performed to classify the log as a recommended logtype (or multiple recommended log types).

Once a log has been properly classified, that log can now be parsedusing the appropriate log parser that has been constructed for that logtype. The log parser may include a set of regular expressionsspecifically constructed for a given log type to extract a designatedset of fields and values from the log. Therefore, failure to identifythe correct log type may cause a failure of the log parsing process,especially if the wrong log parser is used to parse the log. With thepresent approach, a high level of confidence can be gained for theproper identification of the correct log type for an unknown log. Thisserves to more efficiently and effectively implement the parsing stageof log processing, since the appropriate log parser can then be selectedto parse the log.

FIG. 17 illustrates a flowchart of an approach to implement the learningphase according to some embodiments of the invention. At 1702, a set oflogs is identified that correspond to known log types. This set of knownlogs forms the basis of the training data. The set of known logs maycomprise an initial set of training material, or may be provided asfollow-up training materials from a feedback process where previousincorrectly-classified logs are identified and placed within thetraining materials to improve the accuracy of the learning models.

At 1704, the training data is organized by the data's known log types.In some embodiments, a directory structure is employed to organize theknown logs, where each log type corresponds to a sub-directory havingthe logs that are known to be of that log type. Any number of thesedirectory structures may be formed, to hold data for a respective numberof log types for which the training phase is intended to process.

At 1706, the log data is vectorized on a log-type basis. Each set oflogs within a sub-directory for a given log type is transformed into avector and plotted onto a coordinate space. From those vectors, clustersof vectors can be formed, where at 1708, one or more centroidsidentified for the cluster(s). In this manner, a centroid can beidentified for each log type that is currently recognized by the system.

FIG. 18 illustrates one possible approach for organizing the known setof log data within the log analytics system. A top level directory holdsall of the sub-directories for each log type. Here, the top leveldirectory includes sub-directories for log type 1, log type 2, . . . logtype n. Each sub-directory includes the log files within the trainingset that are known to correspond to the log type for that sub-directory.The sub-directory for Log type 1 includes log file_1_(type 1),log_file_2_(type 1), . . . log_file_n_(type 1) that are all within thetraining set and are known to correspond to log type 1. Similarly, thesub-directory for Log type 2 includes log_file_1_(type 2),log_file_2_(type 2), . . . log_file_n_(type 2) that are all within thetraining set and are known to correspond to log type 1.

FIGS. 19-1 through 19-5 illustrate the process for generating thelearning model for the different log types. FIG. 19-1 shows threeexample logs Log 1, Log 2, and Log 3. It is assumed that all three logsare within a training set and are known to be of the same log type. Log1 includes the following content: “Name=Bob Date=May 1URL=www.xyz.com/abcdefghijk/lmnopq”. Log 1 includes the followingcontent: “Name=Joe Date=April 5 URL=www.123.com/4567893409344/dfjgoms”.Log 3 includes the following content: “Name=Sam Date=June 25URL=www.abc.com/rtiosprmskfl/eroskuf”.

The training process begins by converting each of these logs into avector value, and then plotting the vector values within a coordinatespace. FIG. 19-2 illustrates this process for Log 1. Here, the log isconverted into a first type of vector (distribution vector 1904 a),where the distribution/frequency of each character within the log isconsidered to generate the vector. Vector 1904 a is then plotted as apoint 1911 a within coordinate space 1910. In a similar way, the log isconverted into a second type of vector (token vector 1906 a) where thetokens within the log (or at least the top n tokens within the log) areused to generate the token vector 1906 a. Vector 1906 a is then plottedas a point 1913 a within coordinate space 1912.

Each of the other logs undergoes this same process. FIG. 19-3illustrates processing for Log 2, where the log is converted into afirst distribution vector 1904 b and a second token vector 1906 b. Thedistribution vector 1904 b is plotted as a point 1911 b within thecoordinate space 1910, and the token vector 1906 b is plotted as a point1913 b within the coordinate space 1912. Similarly, FIG. 19-4illustrates processing for Log 3, where the log is converted into afirst distribution vector 1904 c and a second token vector 1906 c. Thedistribution vector 1904 c is plotted as a point 1911 c within thecoordinate space 1910, and the token vector 1906 c is plotted as a point1913 c within the coordinate space 1912.

Next, as shown in FIG. 19-5, clustering is performed to identifyclusters of points within the plotted vector points. A similarity radiuscan be established to identify the vectors that cluster together withineach set of plots. Within the coordinate space 1910 for the distributionvectors, a similarity radius 1917 has been established which groupspoints 1911 a, 1911 b, and 1911 c into the same cluster. For thecoordinate space 1912 that corresponds to the token vectors, asimilarity radius 1919 has been established which groups points 1913 a,1913 b, and 1913 c into the same cluster.

Centroids can then be identified for each cluster. Any suitable approachcan be taken to identify the centroids for the clusters. For example,the following equation may be used to identify the center of a cluster:Center=ΣW_(i)V_(i), where i refers to the identifier for a given vectorV within the cluster, and W refers to a weight that is assigned to thatvector. In some embodiments, the weight W is determined by dividing thenumber 1 by the total number of characters within that log. Thisapproach to weighting serves to provide normalization for the differentlogs with respect to the number of characters that may exist within anygiven log.

In the example of FIG. 19-5, application of the above formula results inidentification of centroid 1921 for the cluster of distribution vectors,and centroid 1923 for the cluster of token vectors. This set of dataforms the models that can be used to classify a set of unknown logs.

FIG. 20 shows a flowchart of an approach to implement classificationaccording to some embodiments of the invention. At 2002, identificationis made of the log to be analyzed. This action retrieves one of theunknown logs for processing, e.g., a log that was gathered from a clientlocation and imported into a log analytics system.

Next, at 2004, vector data is generated for the log. This isimplemented, for example for the distribution classifier, by performingfeature extraction to identify the frequency of terms within the logdata, and to then construct term-frequency vectors that correspond tothe log data. For a token classifier, identification of tokens withinthe log is performed to generate a token vector for the log.

At 2006, a similarly comparison is performed for the generated vectordata. In some embodiments, known log data may have been used toconstruct comparison data, e.g., by vectorizing the sample data andconstructing clusters for the sample data using an appropriateclustering algorithm. The similarly comparison is performed by comparingthe vector data for the log under analysis to the vector data for theknown samples (e.g., against the centroid of the cluster for the knownsamples).

At 2008, categorization of the log can be performed using the outputs ofthe comparison process. Distance thresholds may be established todetermine whether the log under analysis is similar enough to beclassified within the category associated with one or more of the knownsamples. For example, analysis may be performed to determine thedistance(s) between the vector for the log under analysis and thevarious centroids that have been identified for the known log types,where a probability value is determined for some or all of the known logtypes.

FIGS. 21-1 through 21-11 illustrate this classification process. FIG.21-1 shows both a distribution model and a token model. The distributionmodel includes a first centroid (Dist_Centroid_(Log 1)) corresponding toa first log type, a second centroid (Dist_Centroid_(Log 2))corresponding to a second log type, and a third centroid(Dist_Centroid_(Log 3)) corresponding to a third log type. Similarly,the token model includes a first centroid (Token_Centroid_(Log 1))corresponding to a first log type, a second centroid(Token_Centroid_(Log 2)) corresponding to a second log type, and a thirdcentroid (Token _Centroid_(Log 3)) corresponding to a third log type. Adistribution classifier 2104 a operates to classify logs according tothe distribution model and the token classifier 2104 b operates toclassify logs according to the token model.

FIG. 21-2 illustrates a log data 2110 being received for classification.Assume that the log type of log data 2110 is currently unknown. FIG.21-3 shows log data 2110 being directed to the distribution classifierfor processing. As illustrated in FIG. 21-4, log data 2110 istransformed into a distribution vector 2105 a, e.g., based upon thedistribution and/or frequency of characters within log data 2110. Vector2105 a is then plotted within the coordinate space of the distributionmodel, as shown in FIG. 21-5.

At this point, distances are calculated between vector 2105 a and thecentroids for the known log types. As shown in FIG. 21-6,Distance_(log 1) identifies the distance between vector 2105 a and thecentroid Dist_Centroid_(Log 1) corresponding to a first log type,Distance_(log 2) identifies the distance between vector 2105 a andcentroid Dist_Centroid_(Log 2) corresponding to a second log type, andDistance_(log 3) identifies the distance between vector 2105 a and thecentroid Dist_Centroid_(Log 3) corresponding to the third log type.These distances will later be used to create classificationrecommendations for the log data 2110 relative to each of the log types1, 2 and/or 3.

FIG. 21-7 shows log data 2110 being directed to the token classifier forprocessing. As illustrated in FIG. 21-8, log data 2110 is transformedinto a token vector 2105 b, e.g., based upon tokens identified withinlog data 2110. Vector 2105 b is then plotted within the coordinate spaceof the token model. Distances are calculated between vector 2105 b andthe centroids within the token model for the known log types. As shownin FIG. 21-9, Distance_(log 1) identifies the distance between vector2105 a and the centroid Token_Centroid_(Log 1) corresponding to a firstlog type, Distance_(log 2) identifies the distance between vector 2105 aand centroid Token_Centroid_(Log 2) corresponding to a second log type,and Distance_(log 3) identifies the distance between vector 2105 a andthe centroid Token_Centroid_(Log 3) corresponding to the third log type.

At this point, as shown in FIG. 21-10, calculation are performed toidentify the appropriate log type that should be recommended for unknownlog data 2110. The distance from the log vector to the centroids foreach of the known log types is analyzed, where the closer the distancefrom the vector to a given centroid, the more likely it is that the logshould be classified as the log type associated with that centroid.Similarly, the greater the distance from the vector to a given centroid,the less likely that log should be classified as the log type associatedwith the centroid.

According to some embodiments, the results from both (multiple)classifiers are considered to identify the appropriate log type for thelog. Weighting may be applied to associate the appropriate weight foreach type of classifier to the final results. For example, assume thatthe distribution classifier is intended to contribute to 20% of thefinal results, whereas the token classifier is intended to contribute80% to the final results. In this situation, the weight W_(Dist) for thedistribution classifier would be set to 0.2 and the weight W_(Token) forthe token classifier would be set to 0.8.

FIG. 21-11 illustrates one possible approach to display classificationresults within a user interface on a display device. In this figure,each of the different log types are presented, along with a percentageprobability that the log should be classified as that log type. In someembodiments, the list is sorted, and only the top n log types with thehighest probability percentages are displayed in the interface. In analternate embodiment, instead of displaying detailed percentageprobabilities, one (or more) recommended classifications are providedfor only those log types which meet a threshold level of similarity(e.g., by establishing a similarity threshold radius when comparing thelog vector to log type centroids).

During the learning phase, processing can be performed to identify anoptimal model for log classification. Recall that a similarity radius isestablished to identify clusters within a training set of data, wherevectors that fall within the scope of the similarity radius can beclustered together. However, vectors that fall outside the scope of thesimilarity radius may fall within the scope of another cluster. It isquite possible for a given log type to correspond to multiple clusters,and hence multiple centroids within a learning model. In fact, if thevectors are spread wide enough, it is possible in the most extreme casefor each sample log for a log type in the training set to correspond toits own centroid. The issue is that the more clusters that exist for agiven log type, the more work may be needed during the classificationprocess to compare an unknown log against each of the centroids.Therefore, it is desirable to identify the least number of centroidsthat nevertheless will allow each and every sample log within thetraining set to classify within the radius of at least one of theminimal number of centroids.

FIG. 22 shows a flowchart of an approach to perform this type ofprocessing. At 2202, the process begins with either a maximum number ofcentroids (and works its way to a smaller and more optimal set ofcentroids) or a minimum number of centroids (and works its way to morecentroids if needed). With the maximum number, each centroid isessentially centered at one of the sample logs in the training set forthe log type being trained. At this point, at 2204, a determination ismade of the coverage of the sample logs that fall within the similarityradius of the centroid(s) as well as the extent of the similarityradius. In particular, if there are any sample logs at all that do notfall within the scope of one of the clusters, then the numbers ofclusters must be adjusted to create a new cluster and/or the similarityradius needs to be adjusted to account for the coverage error. Inaddition, if too many clusters have been identified, then the overlap incoverage by the clusters can be determined at this point.

At 2206, a determination is made whether any adjustments need to bemade. For example, a determination made be made, at 2208, to adjust thenumber of centroids. Depending upon the direction of the processing(e.g., starting from max number of centroids or min number ofcentroids), an action may be taken to either increase to decrease thenumber of centroids. In addition, at 2210, the determination may be madeto adjust the similarity radius for the clustering. A maximizationfunction may be performed to identify the optimal set ofcentroids/radiuses. In addition, a binary search may be performed toidentify one or more optimal solutions.

Under both approaches, the process returns back to 2204 to determinewhether any additional adjustments are needed. If the currentconfiguration of centroids/radius is acceptable, then at 2212, the modelis outputted.

FIG. 23 illustrates the situation where the original similarity radius2312 a was inadequate to correspond to the vectors to be clustered,e.g., where the un-clustered vectors are known to be for the exact samelog type as the vectors that are actually in the cluster and hencefailure to include the un-clustered vectors constitutes an error incoverage for the cluster. In some situations to correct this problem,the radius can be expanded into a modified similarity radius 2312 b.This modified radius 2312 b now correctly clusters all vectors for thelog type without any classification errors.

FIG. 24 illustrates the situation where the original set of centroids isupdated to reflect a new set of centroids. Here, the original analysisidentified only a single centroid 2414 a for cluster 2412 a. The issueis that there are additional vectors that are supposed to be the samelog type as the vectors for cluster 2412 a, but do not classify that wayif only the single centroid 2414 a is in the model. In this situation, anew centroid 2414 b can be identified for a second cluster 2412 b ofvectors for that log type. Here, the model include both centroids 2414 aand 2414 b for the log type, and therefore unknown logs are classifiedrelative to both centroids during the classification process.

Various types of post-modeling testing may be performed to check theaccuracy of the models. One possible test is to identify another set ofknown logs that are known to be of the same log type that was modelled.These additional logs are run through a classifier relative to themodels to determine if they match the correct classifications, within anacceptable threshold. If not, then adjustments may be made to correctthe possible issues, e.g., by adding additional data from the new set ofdata to the training set to correct the models.

An additional optimization that can be performed is to pre-process thelog data to improve the accuracy of the classifications. To explain,consider the log data shown in FIG. 26-1. Here, both Log 1 and Log 2include portions that are very similar (e.g., “Name= . . . ” and “Date=. . . ”), but also include very lengthy portions that are verydissimilar (e.g., the URL portions). In this situation, when convertingthe logs to vectors, the significantly different URL portions mayoverwhelm the parts that are similar, creating excessive mismatchesbetween the vectors for logs that should be classified as the same type.This issue may be partially addressed by using the token vectorizationapproach, but log type/content outliers may nonetheless still createaccuracy issues.

FIG. 25 shows a flowchart of an approach that can be taken to addressthis type of problem. At 2502, pre-processing is performed to analyzethe contents of the log data. In particular, at 2504, common portionsand variable portions of the log are identified. The teachings of U.S.application Ser. No. 14/863,136, filed on Sep. 24, 2015, which is herebyincorporated by reference in its entirety, can be used in conjunctionwith this embodiment, to identify the constant parts and the variableparts of the log.

At 2506, the variable parts are removed from consideration for theanalysis process. In particular, only the constant parts are consideredwhen generating vectors from the log data. Thereafter, at 2508,classifications models are generated using only the constant portions ofthe logs.

FIGS. 26-1 through 26-3 illustrate this process. As noted above, FIG.26-1 shows two logs, where both Log 1 and Log 2 include portions thatare very similar (e.g., “Name= . . . ” and “Date= . . . ”), but alsoinclude very lengthy portions that are very dissimilar (e.g., the URLportions). As illustrated in FIG. 26-2, the common portions and thevariable portions are identified within the log data. For example, the“Name=”, “Date=”, and “URL=” portions are common between all of the logsfor this log type. In contrast, the “Bob”, “Joe”, “May 1”, “April 5”,and URL portions vary between the two logs.

Therefore, the model generation process may operate only against thecommon portions. As shown in FIG. 26-3, the variable portions may beremoved from consideration, leaving only the common portions to bevectorized for model generation. During the classification process, theunknown logs may undergo vectorization in their entirety, or havevariable portions removed in a pre-processing step.

In some cases, the variable portions do provide useful patterns that maybe important for classification purposes. For example, consider againthe logs shown in FIG. 26-1. The variable portions after “Date=”includes “May 1” and “April 5”. Even though these portions vary betweenthe two logs, they are just not random sets of characters, but insteadmay have meaningful contribution given that they are recognizable asdate fields. As such, it may be advantageous in certain circumstances toretain these variable fields during the model generation andclassification process.

FIG. 27 shows a flowchart of an approach that can be taken to implementthis aspect of some embodiments of the invention. At 2702,pre-processing is performed to analyze the contents of the log data. At2704, common portions and variable portions of the log are identified.

In addition, at 2706, “field rule” types may be identified from thevariable portions of the log. This type corresponds to any sequence ofcharacters that is identified based upon a rule definition, and maycorrelate to complex combinations of any numbers of characters,integers, or symbols. A regular expression may be used to express therule for this type. The teachings of U.S. application Ser. No.15/089,180, filed on even date herewith, which is hereby incorporated byreference in its entirety, can be used in conjunction with thisembodiment, to identify the field rule types within a log.

At 2708, the variable parts are then removed from consideration for theanalysis process. This leaves both the constant portions and the fieldrule portions to be considered when generating vectors from the logdata. Thereafter, at 2710, classifications models are generated usingonly the constant portions of the logs.

FIGS. 28-1 through 28-4 illustrate this process. FIG. 28-1 shows twologs, where both Log 1 and Log 2 include portions that are very similar(e.g., “Name= . . . ” and “Date= . . . ”), but also include very lengthyportions that are very dissimilar (e.g., the URL portions). Asillustrated in FIG. 28-2, the common portions and the variable portionsare identified within the log data. For example, the “Name=”, “date=”,and “URL=” portions are common between all of the logs for this logtype. In contrast, the “Bob”, “Joe”, “May 1”, “April 5”, and URLportions vary between the two logs.

Here, the variable portions “May 1” and “April 5” can be recognized asdate fields. Therefore, as shown in FIG. 28-3, these variable portionsare identified as date types within the log.

Thereafter, the model generation process may operate only against thecommon portions and the date type portions. As shown in FIG. 28-4, thevariable portions may be removed from consideration, leaving the commonportions ad the date portions to be vectorized for model generation.During the classification process, the unknown logs may undergovectorization in their entirety, or have variable portions removed in apre-processing step.

Therefore, what has been described is an improved system, method, andcomputer program product for implementing a log analytics method andsystem that can configure, collect, and analyze log records in anefficient manner. In particular, machine learning-based classificationcan be performed to classify logs. This approach is used to group logsautomatically using a machine learning infrastructure.

System Architecture Overview

FIG. 29 is a block diagram of an illustrative computing system 1400suitable for implementing an embodiment of the present invention.Computer system 1400 includes a bus 1406 or other communicationmechanism for communicating information, which interconnects subsystemsand devices, such as processor 1407, system memory 1408 (e.g., RAM),static storage device 1409 (e.g., ROM), disk drive 1410 (e.g., magneticor optical), communication interface 1414 (e.g., modem or Ethernetcard), display 1411 (e.g., CRT or LCD), input device 1412 (e.g.,keyboard), and cursor control.

According to one embodiment of the invention, computer system 1400performs specific operations by processor 1407 executing one or moresequences of one or more instructions contained in system memory 1408.Such instructions may be read into system memory 1408 from anothercomputer readable/usable medium, such as static storage device 1409 ordisk drive 1410. In alternative embodiments, hard-wired circuitry may beused in place of or in combination with software instructions toimplement the invention. Thus, embodiments of the invention are notlimited to any specific combination of hardware circuitry and/orsoftware. In one embodiment, the term “logic” shall mean any combinationof software or hardware that is used to implement all or part of theinvention.

The term “computer readable medium” or “computer usable medium” as usedherein refers to any medium that participates in providing instructionsto processor 1407 for execution. Such a medium may take many forms,including but not limited to, non-volatile media and volatile media.Non-volatile media includes, for example, optical or magnetic disks,such as disk drive 1410. Volatile media includes dynamic memory, such assystem memory 1408.

Common forms of computer readable media includes, for example, floppydisk, flexible disk, hard disk, magnetic tape, any other magneticmedium, CD-ROM, any other optical medium, punch cards, paper tape, anyother physical medium with patterns of holes, RAM, PROM, EPROM,FLASH-EPROM, any other memory chip or cartridge, cloud-based storage, orany other medium from which a computer can read.

In an embodiment of the invention, execution of the sequences ofinstructions to practice the invention is performed by a single computersystem 1400. According to other embodiments of the invention, two ormore computer systems 1400 coupled by communication link 1415 (e.g.,LAN, PTSN, or wireless network) may perform the sequence of instructionsrequired to practice the invention in coordination with one another.

Computer system 1400 may transmit and receive messages, data, andinstructions, including program, i.e., application code, throughcommunication link 1415 and communication interface 1414. Receivedprogram code may be executed by processor 1407 as it is received, and/orstored in disk drive 1410, or other non-volatile storage for laterexecution. Data may be accessed from a database 1432 that is maintainedin a storage device 1431, which is accessed using data interface 1433.

In the foregoing specification, the invention has been described withreference to specific embodiments thereof. It will, however, be evidentthat various modifications and changes may be made thereto withoutdeparting from the broader spirit and scope of the invention. Forexample, the above-described process flows are described with referenceto a particular ordering of process actions. However, the ordering ofmany of the described process actions may be changed without affectingthe scope or operation of the invention. The specification and drawingsare, accordingly, to be regarded in an illustrative rather thanrestrictive sense. In addition, an illustrated embodiment need not haveall the aspects or advantages shown. An aspect or an advantage describedin conjunction with a particular embodiment is not necessarily limitedto that embodiment and can be practiced in any other embodiments even ifnot so illustrated. Also, reference throughout this specification to“some embodiments” or “other embodiments” means that a particularfeature, structure, material, or characteristic described in connectionwith the embodiments is included in at least one embodiment. Thus, theappearances of the phrase “in some embodiment” or “in other embodiments”in various places throughout this specification are not necessarilyreferring to the same embodiment or embodiments.

What is claimed is:
 1. A method comprising: storing, by a log analyticssystem, a plurality of log parsers associated, respectively, with aplurality of log types; obtaining, by the log analytics system, log datafrom a log; identifying within the log data: (a) a first set of fieldnames that are common to at least one log type of a plurality of logtypes, (b) a first set of variable portions comprising field values offields represented by the first set of field names, and (c) a first setof field rule portions, wherein at least one of the first set of fieldnames is defined based on log entry metadata; generating filtered logdata by removing the first set of variable portions from the log data,wherein the filtered log data comprises the first set of field names anddoes not include the field values of the fields represented by the firstset of field names; generating vectors that are (a) based on the firstset of field names in the filtered log data and (b) not based on theremoved first set of variable portions comprising the field values;obtaining a final classification result that classifies the log as beingof a particular type at least by applying, by the log analytics system,the vectors based on the first set of field names to one or moreclassifiers; and based on the final classification result: parsing thelog, by the log analytics system, using a log parser associated with theparticular log type; wherein the first set of field rule portions isretained in the filtered log data subsequent to removing the first setof variable portions; wherein the method is performed by at least onedevice comprising a processor.
 2. The method of claim 1, furthercomprising: applying, by the log analytics system, the filtered log datato a distribution classifier to obtain a first classification result,wherein the distribution classifier classifies the filtered log datausing a distribution model comprising a first plurality of centroidsthat are associated, respectively, with the plurality of log types,wherein applying the filtered log data to the distribution classifiercomprises (a) generating a distribution vector based on one or morefrequencies of one or more characters within the filtered log data, and(b) generating the first classification result based on a first distancebetween the distribution vector and a first centroid in the firstplurality of centroids; applying, by the log analytics system, thefiltered log data to a token classifier to obtain a secondclassification result, wherein the token classifier classifies thefiltered log data using a token model comprising a second plurality ofcentroids that are associated, respectively, with the plurality of logtypes; assigning a first weighting to the first classification result toobtain a first weighted classification result corresponding to thedistribution classifier; assigning a second weighting to the secondclassification result to obtain a second weighted classification resultcorresponding to the token classifier; and combining at least (a) thefirst weighted classification result corresponding to the distributionclassifier and (b) the second weighted classification resultcorresponding to the token classifier to obtain the final classificationresult.
 3. The method of claim 2, wherein: applying the filtered logdata to the token classifier comprises (a) generating a token vectorbased on one or more tokens within the filtered log data, and (b)generating the second classification result based on a second distancebetween the token vector and a second centroid in the second pluralityof centroids.
 4. The method of claim 2, further comprising: applying, bythe log analytics system, the filtered log data to a regular expressionclassifier to obtain a third classification result; and assigning athird weighting to the third classification result to obtain a thirdweighted classification result corresponding to the regular expressionclassifier; wherein to obtain the final classification result, the loganalytics system further combines the third weighted classificationresult corresponding to the regular expression classifier with the firstweighted classification result corresponding to the distributionclassifier and the second weighted classification result correspondingto the token classifier.
 5. The method of claim 2, further comprising:applying, by the log analytics system, the filtered log data to apattern signature classifier to obtain a fourth classification result;and assigning a fourth weighting to the fourth classification result toobtain a fourth weighted classification result corresponding to thepattern signature classifier; wherein to obtain the final classificationresult, the log analytics system further combines the fourth weightedclassification result corresponding to the pattern signature classifierwith the first weighted classification result corresponding to thedistribution classifier and the second weighted classification resultcorresponding to the token classifier.
 6. The method of claim 1, furthercomprising: determining a set of highest probability candidate log typesfor the log, the set of highest probability candidate log typescomprising the final classification result and at least one othercandidate classification result based on the filtered log data; andgenerating a user interface comprising the set of highest probabilitycandidate log types.
 7. The method of claim 1, wherein: the log datacomprises one or more log entries; obtaining the log data from the logcomprises receiving the one or more log entries from one or more loggatherers located in a distributed host environment.
 8. The method ofclaim 2, wherein: based on the first weighting and the second weighting,the first classification result contributes a first percentage towardthe final classification result and the second classification resultcontributes a second percentage toward the final classification result.9. The method of claim 1, the operations further comprise: identifying(c) a first set of field rule portions in the log data, wherein thefield rule portions are retained in the filtered log data subsequent toremoving the first set of variable portions.
 10. The method of claim 2,wherein applying the filtered log data to the distribution classifiercomprises applying a distribution of characters within the filtered logdata to the distribution classifier.
 11. The method of claim 2, whereinapplying the filtered log data to the token classifier comprises:identifying one or more tokens within the filtered log data; andapplying the one or more tokens within the filtered log data to thetoken classifier.
 12. A non-transitory computer readable mediumcomprising instructions which, when executed by one or more hardwareprocessors, causes performance for operations comprising: storing, by alog analytics system, a plurality of log parsers associated,respectively, with a plurality of log types; obtaining, by the loganalytics system, log data from a log; identifying within the log data:(a) a first set of field names that are common to at least one log typeof a plurality of log types, (b) a first set of variable portionscomprising field values of fields represented by the first set of fieldnames, and (c) a first set of field rule portions, wherein at least oneof the first set of field names is defined based on log entry metadata;generating filtered log data by removing the first set of variableportions from the log data, wherein the filtered log data comprises thefirst set of field names and does not include the field values of thefields represented by the first set of field names; generating vectorsthat are (a) based on the first set of field names in the filtered logdata and (b) not based on the removed first set of variable portionscomprising the field values; obtaining a final classification resultthat classifies the log as being of a particular type at least byapplying, by the log analytics system, the vectors based on the firstset of field names to one or more classifiers; and based on the finalclassification result: parsing the log, by the log analytics system,using a log parser associated with the particular log type; wherein thefirst set of field rule portions is retained in the filtered log datasubsequent to removing the first set of variable portions.
 13. Thenon-transitory computer readable medium of claim 12, further comprising:determining a set of highest probability candidate log types for thelog, the set of highest probability candidate log types comprising thefinal classification result and at least one other candidateclassification result based on the filtered log data; generating a userinterface comprising the set of highest probability candidate log types.14. The non-transitory computer readable medium of claim 12, wherein:the log data comprises one or more log entries; obtaining the log datafrom the log comprises receiving the one or more log entries from one ormore log gatherers located in a distributed host environment.
 15. Thenon-transitory computer readable medium of claim 12, further comprising:applying, by the log analytics system, the filtered log data by aregular expression (RE) classifier to obtain a first classificationresult; applying, by the log analytics system, the filtered log data bya non-RE classifier to obtain a second classification result; assigninga first weighting to the first classification result to obtain a firstweighted classification result corresponding to the RE classifier;assigning a second weighting to the second classification result toobtain a second weighted classification result corresponding to thenon-RE classifier; and combining at least (a) the first weightedclassification result corresponding to the RE classifier and (b) thesecond weighted classification result corresponding to the non-REclassifier to obtain the final classification result; wherein: based onthe first weighting and the second weighting, the first classificationresult contributes a first percentage toward the final classificationresult and the second classification result contributes a secondpercentage toward the final classification result.
 16. A systemcomprising: at least one hardware processor; the system being configuredto execute operations comprising: storing, by a log analytics system, aplurality of log parsers associated, respectively, with a plurality oflog types; obtaining, by the log analytics system, log data from a log;identifying within the log data: (a) a first set of field names that arecommon to at least one log type of a plurality of log types, (b) a firstset of variable portions comprising field values of fields representedby the first set of field names, and (c) a first set of field ruleportions, wherein at least one of the first set of field names isdefined based on log entry metadata; generating filtered log data byremoving the first set of variable portions from the log data, whereinthe filtered log data comprises the first set of field names and doesnot include the field values of the fields represented by the first setof field names; generating vectors that are (a) based on the first setof field names in the filtered log data and (b) not based on the removedfirst set of variable portions comprising the field values; obtaining afinal classification result that classifies the log as being of aparticular type at least by applying, by the log analytics system, thevectors based on the first set of field names to one or moreclassifiers; based on the final classification result: parsing the log,by the log analytics system, using a log parser associated with theparticular log type; wherein the first set of field rule portions isretained in the filtered log data subsequent to removing the first setof variable portions.
 17. The system of claim 16, further comprising:determining a set of highest probability candidate log types for thelog, the set of highest probability candidate log types comprising thefinal classification result and at least one other candidateclassification result based on the filtered log data; generating a userinterface comprising the set of highest probability candidate log types.18. The system of claim 16, wherein: the log data comprises one or morelog entries; obtaining the log data from the log comprises receiving theone or more log entries from one or more log gatherers located in adistributed host environment.
 19. The system of claim 16, wherein:applying, by the log analytics system, the filtered log data to apattern signature (PS) classifier to obtain a first classificationresult; applying, by the log analytics system, the filtered log data toa non-PS classifier to obtain a second classification result; assigninga first weighting to the first classification result to obtain a firstweighted classification result corresponding to the PS classifier;assigning a second weighting to the second classification result toobtain a second weighted classification result corresponding to thenon-PS classifier; combining at least (a) the first weightedclassification result corresponding to the PS classifier and (b) thesecond weighted classification result corresponding to the non-PSclassifier to obtain a final classification result that classifies thelog as being of a particular type; and based on the first weighting andthe second weighting, the first classification result contributes afirst percentage toward the final classification result and the secondclassification result contributes a second percentage toward the finalclassification result.